/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package Database;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 *
 * @author PHAMDANH
 */
public class DatabasesManager {
    private List<Database> databases;
    private SQLParser parser;
    private int databaseSelectedIdx;
    public DatabasesManager()
    {
        databases = new ArrayList<Database>();
        parser=new SQLParser();
        databaseSelectedIdx=-1;
    }
    public int getDatabaseIdx()
    {
        return databaseSelectedIdx;
    }
    public void setDatabaseIdx(int idx)
    {
        this.databaseSelectedIdx = idx;
    }
    //load all database in "Data" folder
    public boolean Load()
    { 
        //createTempDatabase();
        File folder = new File("Data");
        if(folder.exists())
        {
            File[] listOfFiles = folder.listFiles(); 
            if(listOfFiles.length>0)
                databaseSelectedIdx=0;
            for(int i=0;i<listOfFiles.length;i++)
            {
                if(listOfFiles[i].isFile())
                {
                    try
                    {
                        FileInputStream fis = new FileInputStream(listOfFiles[i]);
                        ObjectInputStream ois = new ObjectInputStream(fis);
                        try {
                            databases.add((Database)ois.readObject());
                        } catch (ClassNotFoundException ex) {
                            Logger.getLogger(DatabasesManager.class.getName()).log(Level.SEVERE, null, ex);
                        }
                        ois.close();
                    }catch (IOException ioex)
                    {
                    }
                }
            }
            return true;
        }
        else
        {
            folder.mkdir();
            return true;
        }
    }
    public List<Database> getDatabases()
    {
        return databases;
    }
    //Save all database
    public boolean SaveAll() 
    { 
        int count = 0;
        for(int i=0;i<databases.size();i++)
            if(databases.get(i).Save()==false)
                count++;
        if(count>0)
            return false;
        return true;
    }
    
    //Save one database
    public boolean Save(String name)
    {
        for(int i=0;i<databases.size();i++)
            if(databases.get(i).getName().equals(name))
                return databases.get(i).Save();
        return false;
    }
    //Kiểm tra tồn tại database có tên databaseName chưa
    public boolean IsExistDatabase(String databaseName)
    {
        for(int i=0;i<databases.size();i++)
            if(databases.get(i).getName().toLowerCase().equals(databaseName.toLowerCase()))
                return true;
        return false;
    }
//    public void createTempDatabase()
//    {
//        Database school = new Database("QLTruongHoc");
//        school.AddTable("HocSinh");
//        school.AddTable("Lop");
//        List<Table> tables = school.getTable();
//        tables.get(0).AddColumn("MaHS", Integer.class, false);
//        tables.get(0).AddColumn("TenHS", String.class, true);
//        tables.get(0).AddColumn("Lop", Integer.class, true);
//        tables.get(1).AddColumn("MaLop", Integer.class, false);
//        tables.get(1).AddColumn("TenLop", String.class, true);
//        List<String> primaryKey = new ArrayList<String>();
//        primaryKey.add("MaHS");
//        primaryKey.add("TenHS");
//        List<Object> data = new ArrayList<Object>();
//        data.add(1);
//        data.add("Tuan");
//        data.add(2);
//        tables.get(0).setPrimaryKey(primaryKey);
//        tables.get(0).InsertRow(data);
//        Database thuvien= new Database("QLThuVien");
//        thuvien.AddTable("Sach");
//        thuvien.AddTable("DocGia");
//        List<Table> tables2 = thuvien.getTable();
//        tables2.get(0).AddColumn("MaSach", Integer.class, false);
//        tables2.get(0).AddColumn("TenSach", String.class, true);
//        tables2.get(0).AddColumn("TacGia", String.class, true);
//        tables2.get(1).AddColumn("MaDocGia", Integer.class, false);
//        tables2.get(1).AddColumn("TenDocGia", String.class, true);        
//        databases.add(school);
//        databases.add(thuvien);  
//        //for(int i=0;i<databases.size();i++)
//            //databases.get(i).Save();
//    }
    
    ///////////////
    public boolean ExecuteNonQuery(String str)
    {
        return true;
    }
    public Object ExecuteQuery(String str)
    {
        str.toLowerCase();
        str=str.trim();

        if (str.contains("select"))
        {
            if(parser.CheckSelectSyntax(str)==true)
                return Select(parser);
        }
        if(str.contains("insert"))
        {
            if(parser.CheckInsertSyntax(str)==true)
            {
                List<Object> temp=new ArrayList<Object>();
                for(int i=0;i<parser.GetListValue().size();i++)
                    temp.add(parser.GetListValue().get(i).replaceAll("\'", ""));
                return Insert(parser.GetDatabaseName(),parser.GetListTableName(),parser.GetFieldName(),temp);
            }
        }
        if(str.contains("update"))
        {
            if(parser.CheckUpdateSyntax(str)==true)
            {
                return Update(parser.GetDatabaseName(),parser.GetListTableName(),parser.GetWhereCondition(),parser.GetListUpdateValue());
            }
        }
        if(str.contains("delete"))
        {
            if(parser.CheckDeleteSyntax(str) ==true)
                Delete(parser.GetDatabaseName(), parser.GetListTableName(), parser.GetWhereCondition());
        }
        return null;
    }
    public Table Select(SQLParser parser)
    {
        Database usingdatabase=new Database("temp");
        
        if(!"".equals(parser.GetDatabaseName()))
        {
            boolean flag=false;
            for(int i=0;i<databases.size();i++)
            {
                String comparedatabase=databases.get(i).getName();
                comparedatabase=comparedatabase.trim().toLowerCase();
                if(comparedatabase.equals(parser.GetDatabaseName()))
                {
                    usingdatabase=databases.get(i);
                    flag=true;
                    break;
                }
            }
            if(flag==false)
                return null;
        }
        else
            usingdatabase=databases.get(databaseSelectedIdx);
        
        Table tb = new Table("ResultTable");

        List<Table> tables= new ArrayList<Table>();
        List<String> tableNames= parser.GetListTableName();
        for(int i=0;i<tableNames.size();i++)
        {
            for(int j=0;j<usingdatabase.getTable().size();j++)
            {
                String comparetablename=usingdatabase.getTable().get(j).getName();
                comparetablename=comparetablename.trim().toLowerCase();
                if(tableNames.get(i).equals(comparetablename))
                {
                    tables.add(new Table(usingdatabase.getTable().get(j).getName()));
                    for(int z=0;z<usingdatabase.getTable().get(j).getColumns().size();z++)
                    {
                        tables.get(tables.size()-1).AddColumn(usingdatabase.getTable().get(j).getColumns().get(z).getName(), usingdatabase.getTable().get(j).getColumns().get(z).getType(), usingdatabase.getTable().get(j).getColumns().get(z).getAllowNull());
                        for(int q=0;q<usingdatabase.getTable().get(j).getColumns().get(z).getData().size();q++)
                        {
                            if(tables.get(tables.size()-1).getColumns().get(tables.get(tables.size()-1).getColumns().size()-1).getData().size()<=q)
                                tables.get(tables.size()-1).getColumns().get(tables.get(tables.size()-1).getColumns().size()-1).getData().add(usingdatabase.getTable().get(j).getColumns().get(z).getData().get(q));
                            else
                                tables.get(tables.size()-1).getColumns().get(tables.get(tables.size()-1).getColumns().size()-1).setData(q,usingdatabase.getTable().get(j).getColumns().get(z).getData().get(q));
                        }
                    }
                }
            }
        }        
        if(tables.size()<tableNames.size())//Không tìm thấy đủ table
            return null;
        
        List<String> tableNames2 = new ArrayList<String>();
        tableNames2=parser.getJoinTable();
        if(tableNames2.size()>0)
        {
            for(int i=0;i<tableNames2.size();i++)
            {
                for(int j=0;j<usingdatabase.getTable().size();j++)
                {
                    String comparetablename=usingdatabase.getTable().get(j).getName().trim().toLowerCase();
                    if(tableNames2.get(i).equals(comparetablename))
                    {
                        tables.add(usingdatabase.getTable().get(j));
                    }
                }
            } 
            if(tables.size()!=2)
                return null;
        }
        
        //them cac col vao result table
        for(int i=0;i<tables.size();i++)
        {
            for(int j=0;j<tables.get(i).getColumns().size();j++)
            {
                Column col=tables.get(i).getColumns().get(j);
                tb.getColumns().add(new Column(col.getName(), col.getType(), col.getAllowNull()));
                for(int z=0;z<col.getData().size();z++)
                {
                    Object temp=new Object();
                    temp=col.getData().get(z);
                    tb.getColumns().get(tb.getColumns().size()-1).getData().add(temp);
                }
            }
        }
        
        List<Object> data = new ArrayList<Object>();
        
        if(parser.GetJoinCondition().GetVeTrai().size()>=1)
        {
            for(int i=0;i<tb.getColumns().size();i++)
                tb.getColumns().get(i).getData().clear();
            for(int i=0;i<parser.GetJoinCondition().GetVeTrai().size();i++)
            {
                //Gan du lieu cho result table
                Table T1;
                Table T2;
                List<Object> T1hash=new ArrayList<Object>();

                String comparetable=tables.get(0).getName().trim().toLowerCase();
                if(comparetable.equals(parser.GetJoinCondition().GetVeTrai().get(i).getColumn().TableName))
                    T1=tables.get(0);
                else
                    T1=tables.get(1);
                
                if(T1==null)
                    return null;
                for(int j=0;j<T1.getColumns().size();j++)
                    T1.getColumns().get(j).setName(T1.getColumns().get(j).getName().trim().toLowerCase());
                int dc = T1.getColumnIndex(parser.GetJoinCondition().GetVeTrai().get(i).getColumn().ColumnName); 
                List<Object> dr = T1.getColumns().get(dc).getData();
                if(dr.isEmpty()||dr==null)
                    return SelectCol(tables, tb, parser);
                T1hash=dr;
                //T1hash.get(T1hash.size()-1).setData(dr);
                //T1hash.Add(dr[dc], dr); 

                comparetable=tables.get(1).getName().trim().toLowerCase();
                if(comparetable.equals(parser.GetJoinCondition().GetVePhai().get(i).getColumn().TableName))
                    T2=tables.get(1);
                else
                    T2=tables.get(0);
                
                if(T2==null)
                    return null;
                for(int j=0;j<T2.getColumns().size();j++)
                    T2.getColumns().get(j).setName(T2.getColumns().get(j).getName().trim().toLowerCase());
                int dcLookup = T2.getColumnIndex(parser.GetJoinCondition().GetVePhai().get(i).getColumn().ColumnName); 
                if(dcLookup!=-1)
                    dr = T2.getColumns().get(dcLookup).getData();
                else
                    return null;
                if(dr.isEmpty()||dr==null)
                    return SelectCol(tables, tb, parser);
                
                for(int j=0;j<T1hash.size();j++)
                {
                    for(int z=0;z<dr.size();z++)
                    {
                        Object key = dr.get(z);
                        if (T1hash.get(j)!=null&&T1hash.get(j).equals(key)
                                ||T1hash.get(j)==null&&key==null)
                        {

                            data.clear();
                            comparetable=tables.get(0).getName().trim().toLowerCase();
                            if(comparetable.equals(parser.GetJoinCondition().GetVeTrai().get(i).getColumn().TableName))
                            {     
                                for (int q = 0; q < T1.getColumns().size(); q++) 
                                    data.add(T1.getColumns().get(q).getData().get(j));
                                for (int q = 0; q < T2.getColumns().size(); q++) 
                                    //data[z + T1.getColumns().size()] = T2.getColumns().get(z).getData().get(j);
                                    data.add(T2.getColumns().get(q).getData().get(z));
                            }
                            else
                            {
                                for (int q = 0; q < T2.getColumns().size(); q++) 
                                    data.add(T2.getColumns().get(q).getData().get(j));
                                for (int q = 0; q < T1.getColumns().size(); q++) 
                                    data.add(T1.getColumns().get(q).getData().get(z));
                            }
                            tb.InsertRow(data);
                        }  
                    }
                }
            }
        }
        else
        {
            if(tables.size()==2)
            {
                for(int i=0;i<tb.getColumns().size();i++)
                    tb.getColumns().get(i).getData().clear();
                for(int j=0;j<tables.get(0).getColumns().get(0).getData().size();j++)
                {
                    for(int z=0;z<tables.get(1).getColumns().get(0).getData().size();z++)
                    {  
                        data.clear();
                        for (int q = 0; q < tables.get(0).getColumns().size(); q++) 
                            data.add(tables.get(0).getColumns().get(q).getData().get(z));
                        for (int q = 0; q < tables.get(1).getColumns().size(); q++)
                            data.add(tables.get(1).getColumns().get(q).getData().get(z));
                        tb.InsertRow(data);    
                    }
                }   
            }
            else
                if(tables.size()!=1)
                    return null;
        }
        
        List<Boolean[]> tempresult=new ArrayList<Boolean[]>();
        for(int i=0;i<parser.GetWhereCondition().GetVeTrai().size();i++)
        {
            /*String tbname=null;
            if(i<tables.get(0).getColumns().size())
                tbname=tables.get(0).getName().trim().toLowerCase();
            else
                tbname=tables.get(1).getName().trim().toLowerCase();*/
            if(parser.GetWhereCondition().GetVeTrai().get(i).getColumn()!=null&&
                    (parser.GetWhereCondition().GetVeTrai().get(i).getColumn().TableName.equals(tables.get(0).getName().trim().toLowerCase())
                    ||parser.GetWhereCondition().GetVeTrai().get(i).getColumn().TableName.equals(tables.get(1).getName().trim().toLowerCase())))
            {
                boolean flag=false;
                columnloop:
                for(int j=0;j<tb.getColumns().size();j++)
                {
                    String temp=tb.getColumns().get(j).getName().trim().toLowerCase();
                    if(temp.equals(parser.GetWhereCondition().GetVeTrai().get(i).getColumn().ColumnName))
                    {
                        flag=true;
                        Boolean[] colrow=new Boolean[tb.getColumns().get(j).getData().size()];
                            for(int z=0;z<colrow.length;z++)
                                colrow[z]=true;
                        tempresult.add(colrow);
                        for(int z=0;z<tb.getColumns().get(j).getData().size();z++)
                        {
                            if(tb.getColumns().get(j).getType()==String.class)
                            {
                                if(parser.GetWhereCondition().GetVePhai().get(i).CompareStr(tb.getColumns().get(j).getData().get(z),parser.GetWhereCondition().GetOperator().get(i))==false)
                                    tempresult.get(tempresult.size()-1)[z]=false;
                            }
                            else
                                if(parser.GetWhereCondition().GetVePhai().get(i).CompareInt(tb.getColumns().get(j).getData().get(z),parser.GetWhereCondition().GetOperator().get(i))==false)
                                    tempresult.get(tempresult.size()-1)[z]=false;
                        }
                        break columnloop;
                    }
                }
                if(flag==false)
                    return null;
            }
            else
                return null;
        }
        
        if(tempresult.size()>=1)
        {
            if(parser.GetWhereCondition().GetAndOrList().size()>0)
            {
                for(int j=0;j<parser.GetWhereCondition().GetAndOrList().size();j++)
                {
                    if(tempresult.size()==1)
                        return null;
                    tempresult.set(0, Combine(tempresult,parser.GetWhereCondition().GetAndOrList().get(j)));  
                    if(tempresult.size()>=2)
                        tempresult.remove(1);                             
                }
            }
            
            for(int i=tempresult.get(0).length-1;i>=0;i--)
                if(tempresult.get(0)[i]!=true)
                    tb.RemoveRow(i);
        }
        Table kq=SelectCol(tables,tb,parser);

        return kq;
    }
    
    public Table SelectCol(List<Table> tables,Table tb,SQLParser parser)
    {
        for(int i=0;i<tables.size();i++)
        {
            tables.get(i).setName(tables.get(i).getName().toLowerCase());
            for(int j=0;j<tables.get(i).getColumns().size();j++)
                tables.get(i).getColumns().get(j).setName(tables.get(i).getColumns().get(j).getName().trim().toLowerCase());
        }
        for(int i=0;i<tb.getColumns().size();i++)
            tb.getColumns().get(i).setName(tb.getColumns().get(i).getName().trim().toLowerCase());
        Table kq=new Table("Result");
        for(int i=0;i<parser.getListColumn().size();i++)
        {
            if(parser.getListColumn().get(i).ColumnName.equals("*"))
                    kq.setColumns(tb.getColumns());
            else
            {
                if(parser.getListColumn().get(i).TableName.equals(tables.get(0).getName()))
                    if(tables.get(0).getColumnIndex(parser.getListColumn().get(i).ColumnName)!=-1)
                            kq.getColumns().add(tb.getColumns().get(tables.get(0).getColumnIndex(parser.getListColumn().get(i).ColumnName)));

                if(tables.size()==2)
                {
                    if(parser.getListColumn().get(i).TableName.equals(tables.get(1).getName()))
                        if(tables.get(1).getColumnIndex(parser.getListColumn().get(i).ColumnName)!=-1)
                                kq.getColumns().add(tb.getColumns().get(tables.get(0).getColumns().size()+tables.get(1).getColumnIndex(parser.getListColumn().get(i).ColumnName)));
                }
            }
        }
        return kq;
    }
        
    public String Insert(String database, List<String> tables, List<String> columns, List<Object> row)
    {
        Database usingdatabase=new Database("temp");
        
        if(!"".equals(database))
        {
            boolean flag=false;
            for(int i=0;i<databases.size();i++)
            {
                String comparedatabase=databases.get(i).getName();
                comparedatabase=comparedatabase.trim().toLowerCase();
                if(comparedatabase.equals(database))
                {
                    usingdatabase=databases.get(i);
                    flag=true;
                    break;
                }
            }
            if(flag==false)
                return "Không tồn tại Database tên " + database;
        }
        else
            usingdatabase=databases.get(databaseSelectedIdx);

        Table temp=null;
        for(int i=0;i<usingdatabase.getTable().size();i++)
        {
            String comparetable=usingdatabase.getTable().get(i).getName();
            comparetable=comparetable.trim().toLowerCase();
            if(comparetable.equals(tables.get(0)))
            {
                temp=new Table(usingdatabase.getTable().get(i).getName());
                for(int j=0;j<usingdatabase.getTable().get(i).getColumns().size();j++)
                {
                    temp.AddColumn(usingdatabase.getTable().get(i).getColumns().get(j).getName(), usingdatabase.getTable().get(i).getColumns().get(j).getType(), usingdatabase.getTable().get(i).getColumns().get(j).getAllowNull());
                    for(int z=0;z<usingdatabase.getTable().get(i).getColumns().get(j).getData().size();z++)
                    {
                        if(temp.getColumns().get(temp.getColumns().size()-1).getData().size()<=z)
                            temp.getColumns().get(temp.getColumns().size()-1).getData().add(usingdatabase.getTable().get(i).getColumns().get(j).getData().get(z));
                        else
                            temp.getColumns().get(temp.getColumns().size()-1).setData(z,usingdatabase.getTable().get(i).getColumns().get(j).getData().get(z));
                    }
                }
                break;
            }
        }
        
        if(temp==null)
            return "Không tồn tại table "+tables.get(0);
        else
        {
            List<Object> data=new ArrayList<Object>();
            for(int i=0;i<temp.getColumns().size();i++)
                    data.add(null);
            if(columns.size()>0)
            {
                for(int i=0;i<columns.size();i++)
                {
                    boolean flag=false;

                    for(int j=0;j<temp.getColumns().size();j++)
                    {
                        String comparecol=temp.getColumns().get(j).getName().trim().toLowerCase();
                        if(comparecol.equals(columns.get(i)))
                        {
                            data.set(j, row.get(i));
                            flag=true;
                        }
                    }
                    if(flag==false)
                        return "Không tồn tại cột "+columns.get(i);
                }
            }
            else
                for(int j=0;j<temp.getColumns().size();j++)
                    data.set(j, row.get(j));
             
            if(usingdatabase.InsertRow(data, tables.get(0))==true)
            {
                usingdatabase.Save();
                return "Success";
            }
            else
                return "Fail"; 
        }
    }
        
    public String Update(String database, List<String> tables, WhereCondition condition, List<String> row)
    {
        Database usingdatabase=new Database("temp");
        
        if(!"".equals(database))
        {
            boolean flag=false;
            for(int i=0;i<databases.size();i++)
            {
                String comparedatabase=databases.get(i).getName();
                comparedatabase=comparedatabase.trim().toLowerCase();
                if(comparedatabase.equals(database))
                {
                    usingdatabase=databases.get(i);
                    flag=true;
                    break;
                }
            }
            if(flag==false)
                return "Không tồn tại Database tên " + database;
        }
        else
            usingdatabase=databases.get(databaseSelectedIdx);
            
        Table temp=null;
        for(int i=0;i<usingdatabase.getTable().size();i++)
        {
            String comparetable=usingdatabase.getTable().get(i).getName();
            comparetable=comparetable.trim().toLowerCase();
            if(comparetable.equals(tables.get(0)))
            {
                temp=new Table(usingdatabase.getTable().get(i).getName());
                for(int j=0;j<usingdatabase.getTable().get(i).getColumns().size();j++)
                {
                    temp.AddColumn(usingdatabase.getTable().get(i).getColumns().get(j).getName(), usingdatabase.getTable().get(i).getColumns().get(j).getType(), usingdatabase.getTable().get(i).getColumns().get(j).getAllowNull());
                    for(int z=0;z<usingdatabase.getTable().get(i).getColumns().get(j).getData().size();z++)
                    {
                        if(temp.getColumns().get(temp.getColumns().size()-1).getData().size()<=z)
                            temp.getColumns().get(temp.getColumns().size()-1).getData().add(usingdatabase.getTable().get(i).getColumns().get(j).getData().get(z));
                        else
                            temp.getColumns().get(temp.getColumns().size()-1).setData(z,usingdatabase.getTable().get(i).getColumns().get(j).getData().get(z));
                    }
                }
                break;
            }
        }
        if(temp==null)
            return "Không tồn tại table "+tables.get(0);
        else
        {
            
            List<Boolean[]> kq=new ArrayList<Boolean[]>();
            for(int i=0;i<condition.GetVeTrai().size();i++)
            {
                if(condition.GetVeTrai().get(i).getColumn().TableName.equals(temp.getName().trim().toLowerCase()))
                {
                    columnloop:
                    for(int j=0;j<temp.getColumns().size();j++)
                    {
                        String tempstr=temp.getColumns().get(j).getName().trim().toLowerCase();
                        if(tempstr.equals(condition.GetVeTrai().get(i).getColumn().ColumnName))
                        {
                            Boolean[] colrow=new Boolean[temp.getColumns().get(j).getData().size()];
                            for(int z=0;z<colrow.length;z++)
                                colrow[z]=true;
                            kq.add(colrow);
                            for(int z=0;z<temp.getColumns().get(j).getData().size();z++)
                            {
                                if(temp.getColumns().get(j).getType()==String.class)
                                {
                                    if(condition.GetVePhai().get(i).CompareStr(temp.getColumns().get(j).getData().get(z),condition.GetOperator().get(i))==false)
                                        kq.get(kq.size()-1)[z]=false;
                                }
                                else
                                    if(condition.GetVePhai().get(i).CompareInt(temp.getColumns().get(j).getData().get(z),condition.GetOperator().get(i))==false)
                                        kq.get(kq.size()-1)[z]=false;
                            }
                            break columnloop;
                        } 
                    }
                }
            }
            
            if(kq.size()>=1)
            {
                if(condition.GetAndOrList().size()>0)
                {
                    for(int j=0;j<condition.GetAndOrList().size();j++)
                    {
                        if(kq.size()==1)
                            return "Overload And/Or conditions";
                        kq.set(0, Combine(kq,condition.GetAndOrList().get(j)));  
                        if(kq.size()>=2)
                            kq.remove(1);                             
                    }
                }
                
                for(int i=0;i<kq.get(0).length;i++)
                    if(kq.get(0)[i]==true)
                    {
                        for(int r=0;r<row.size();r++)
                        {
                            if(!row.get(r).contains("="))
                                return "Sai cú pháp";
                            else
                            {
                                String col=row.get(r).substring(0, row.get(r).indexOf("="));
                                col.trim().toLowerCase();
                                for(int j=0;j<temp.getColumns().size();j++)
                                {
                                    String comparecol=temp.getColumns().get(j).getName().trim().toLowerCase();
                                    if(comparecol.equals(col))
                                    {
                                        String updatevalue=row.get(r).substring(row.get(r).indexOf("=")+1, row.get(r).length());
                                        if(updatevalue.contains("'")&&updatevalue.indexOf("'")!=updatevalue.lastIndexOf("'"))
                                        {
                                            updatevalue=updatevalue.replace("'", "");
                                            updatevalue.trim();
                                            if(temp.getColumns().get(j).SetData(i, updatevalue)==false)
                                                return "Fail";
                                        }
                                        else
                                        {
                                            if(updatevalue.equals("null"))
                                            {
                                                if(temp.getColumns().get(j).SetData(i, null)==false)
                                                    return "Fail";
                                            }
                                            else
                                            {
                                                if(temp.getColumns().get(j).SetData(i, updatevalue)==false)
                                                    return "Fail";
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                
                for(int i=0;i<kq.get(0).length;i++)
                    if(kq.get(0)[i]==true)
                    {
                        for(int r=0;r<row.size();r++)
                        {
                            for(int j=0;j<usingdatabase.getTable().size();j++)
                                if(usingdatabase.getTable().get(j).getName().equals(temp.getName()))
                                {                
                                    String col=row.get(r).substring(0, row.get(r).indexOf("="));
                                    col.trim().toLowerCase();
                                    for(int z=0;z<temp.getColumns().size();z++)
                                    {
                                        String comparecol=usingdatabase.getTable().get(j).getColumns().get(z).getName().trim().toLowerCase();
                                        if(comparecol.equals(col))
                                        {
                                            String updatevalue=row.get(r).substring(row.get(r).indexOf("=")+1, row.get(r).length());
                                            if(updatevalue.contains("'")&&updatevalue.indexOf("'")!=updatevalue.lastIndexOf("'"))
                                            {
                                                updatevalue=updatevalue.replace("'", "");
                                                updatevalue.trim();
                                                usingdatabase.getTable().get(j).getColumns().get(z).SetData(i, updatevalue);
                                            }
                                            else
                                            {
                                                if(updatevalue.equals("null"))
                                                    usingdatabase.getTable().get(j).getColumns().get(z).SetData(i, null);
                                                else
                                                    usingdatabase.getTable().get(j).getColumns().get(z).SetData(i, updatevalue);
                                            }
                                        }
                                    }
                                }
                        }
                    }
                usingdatabase.Save();
                return "Success";
            }
            else
                return "Can't found a row to Update";
        }
    }
    
    public String Delete(String database, List<String> tables, WhereCondition condition)
    {
        Database usingdatabase=new Database("temp");
        
        if(!"".equals(database))
        {
            boolean flag=false;
            for(int i=0;i<databases.size();i++)
            {
                String comparedatabase=databases.get(i).getName();
                comparedatabase=comparedatabase.trim().toLowerCase();
                if(comparedatabase.equals(database))
                {
                    usingdatabase=databases.get(i);
                    flag=true;
                    break;
                }
            }
            if(flag==false)
                return "Không tồn tại Database tên " + database;
        }
        else
            usingdatabase=databases.get(databaseSelectedIdx);
        
        Table temp=null;
        for(int i=0;i<usingdatabase.getTable().size();i++)
        {
            String comparetable=usingdatabase.getTable().get(i).getName();
            comparetable=comparetable.trim().toLowerCase();
            if( comparetable.equals(tables.get(0)))
            {
                temp=new Table(usingdatabase.getTable().get(i).getName());
                for(int j=0;j<usingdatabase.getTable().get(i).getColumns().size();j++)
                {
                    temp.AddColumn(usingdatabase.getTable().get(i).getColumns().get(j).getName(), usingdatabase.getTable().get(i).getColumns().get(j).getType(), usingdatabase.getTable().get(i).getColumns().get(j).getAllowNull());
                    for(int z=0;z<usingdatabase.getTable().get(i).getColumns().get(j).getData().size();z++)
                    {
                        if(temp.getColumns().get(temp.getColumns().size()-1).getData().size()<=z)
                            temp.getColumns().get(temp.getColumns().size()-1).getData().add(usingdatabase.getTable().get(i).getColumns().get(j).getData().get(z));
                        else
                            temp.getColumns().get(temp.getColumns().size()-1).setData(z,usingdatabase.getTable().get(i).getColumns().get(j).getData().get(z));
                    }
                }
                //temp=usingdatabase.getTable().get(i);
                break;
            }
        }
        if(temp==null)
            return "Không tồn tại table "+tables.get(0);
        else
        {
            
            List<Boolean[]> kq=new ArrayList<Boolean[]>();
            for(int i=0;i<parser.GetWhereCondition().GetVeTrai().size();i++)
            {
                if(condition.GetVeTrai().get(i).getColumn().TableName.equals(temp.getName().trim().toLowerCase()))
                {
                    columnloop:
                    for(int j=0;j<temp.getColumns().size();j++)
                    {
                        String tempstr=temp.getColumns().get(j).getName().trim().toLowerCase();
                        if(tempstr.equals(condition.GetVeTrai().get(i).getColumn().ColumnName))
                        {
                            Boolean[] colrow=new Boolean[temp.getColumns().get(j).getData().size()];
                            for(int z=0;z<colrow.length;z++)
                                colrow[z]=true;
                            kq.add(colrow);
                            for(int z=0;z<temp.getColumns().get(j).getData().size();z++)
                            {
                                if(temp.getColumns().get(j).getType()==String.class)
                                {
                                    if(condition.GetVePhai().get(i).CompareStr(temp.getColumns().get(j).getData().get(z),condition.GetOperator().get(i))==false)
                                        kq.get(kq.size()-1)[z]=false;
                                }
                                else
                                    if(condition.GetVePhai().get(i).CompareInt(temp.getColumns().get(j).getData().get(z),condition.GetOperator().get(i))==false)
                                        kq.get(kq.size()-1)[z]=false;
                            }
                            break columnloop;
                        } 
                    }
                }
            }
            
            if(kq.size()>=1)
            {
                if(condition.GetAndOrList().size()>0)
                {
                    for(int j=0;j<condition.GetAndOrList().size();j++)
                    {
                        if(kq.size()==1)
                            return "Overload And/Or conditions";
                        kq.set(0, Combine(kq,condition.GetAndOrList().get(j)));  
                        if(kq.size()>=2)
                            kq.remove(1);                             
                    }
                }
                
                for(int i=kq.get(0).length-1;i>=0;i--)
                    if(kq.get(0)[i]==true)
                    {
                        if(temp.RemoveRow(i)==false)
                            return "Fail";
                    }
                
               for(int i=kq.get(0).length-1;i>=0;i--)
                    if(kq.get(0)[i]==true)
                    {
                        for(int j=0;j<usingdatabase.getTable().size();j++)
                            if(usingdatabase.getTable().get(j).getName().equals(temp.getName()))
                                usingdatabase.getTable().get(j).RemoveRow(i);
                    }
                usingdatabase.Save();
                return "Success";
            }
            else
                return "Can't found a row to Delete";}
    }

    public Boolean[] Combine(List<Boolean[]> tables,String condition)
    {
        Boolean[] result=tables.get(0);
        if(condition.trim().toLowerCase().equals("and"))
        {
            for(int i=0;i<tables.get(0).length;i++)
               result[i]=tables.get(0)[i]&&tables.get(1)[i];
        }
        else
        {
            for(int i=0;i<tables.get(0).length;i++)
               result[i]=tables.get(0)[i]||tables.get(1)[i];
        }
        return result;
    }
}
